Remember (procName [, procName]… | All)

Ignore (procname [, procName]… | All)

Dispose (varName)

New (vwRefNum, varName)



Additional Interpreter Commands:





DisposeMsg (theMsg)

MessageTypeCount (msgType) <- theCount

MessageCount <- theCount

ReadMessageOfType (theType, theMsg) <- theResult

ReadMessage (theMsg) <- theResult

MessageSend (theMsg, async)

DisposeMsgPtr (msgPtr)

NewMsgPtr (blkCount) <- outMsgPtr



SetMyUserName (userName)

GetMyUserName <- userName

GetIndUserNum (n) <- userNum

GetUserNum (userName) <- userNum

GetUserName (userNum) <- userName

CountUsers <- userCount



Messaging Operations:





SetPollParams (msg, minTime, maxTime, dlogID, canCancel)

GetPollParams <- msg, minTime, maxTime, dlogID, canCancel

PopPollProc

PushPollProc (@pollProc,@var)

PollLocks (theLocks)



LockQuery (lockNum) <- lockInfo

LockConflicts (theLocks) <- lockCount, lockList

GetOwner <- ownerID

SetOwner (ownerID)



ReleaseLock (theLocks)

LockStatus (theLocks) <- theStatus

GetLockNumber (theLocks) <- theLocks



ExtLockExists (theType, theData, firstByte, count, permission) <- theResult

ExtLockTest (theType, theData, firstByte, count, permission) <- theResult

ExtLock (theType, theData, firstByte, count, permission, wait) <- theResult



Locking Operations:





DebugAudit (n)

DebugWriteln (n, aStr)

DebugWrite (n, aStr)

DebugClearTxt (n)



Debugger Functions:





Decompress (dataHdl) <- theResult

Compress (dataHdl) <- theResult

Decrypt (@data, dataSize, key)

Encrypt (@data, dataSize, key)



Utilities:





SQGetConnection (fileName, connectFile) <- theResult

SQGetIndConnection (fileName, conNum) <- connectFile

     {, fieldName, fieldLength}… | false

SQGetKeyInfo (fileName, keyName) <- keyName, dupAllowed, ULCase, fieldCount

     {, fieldName, fieldLength}…

SQGetIndKeyInfo (fileName, keyNum) <- keyName, dupAllowed, ULCase, fieldCount

     fieldCount | false

SQGetFieldInfo (fileName, fieldName) <- fieldName, fieldType, fieldLength,

     fieldCount

SQGetIndFieldInfo (fileName, fieldNum) <- fieldName, fieldType, fieldLength,

SQGetFileInfo (fileName) <- fileName, fileType, fieldCount, keyCount, conCount | false

SQGetIndFileInfo (fileNum) <- fileName, fileType, fieldCount, keyCount, conCount

SQCountFiles <- theResult



Database Schema Queries:





SBUpdate (blockType, blockID, @data)

SBRead (blockType, blockID, @data)

SBGetSize (blockType, blockID) <- theResult

SBResize (blockType, blockID, newSize)

SBDelete (blockType, blockID)

SBLockExists (blockType, blockID, permission) <- theResult

SBLockTest (blockType, blockID, permission) <- theResult

SBGrab (blockType, blockID, permission, wait)

SBCreate (blockType, blockID, blockSize, @data)



Static Block Operations:





REEnd (showProgress, progressProc)

RERmveCon (connectFile)

REAddCon (connectFile)

     dupAllowed)

REChgKey (keyName, fldCount {, fldName, fldLength, ascending}…, ULCase,

RERmveKey (keyName)

     dupAllowed)

RENewKey (keyName, fldCount {, fldName, fldLength, ascending}…, MaintainCount, ULCase,

REChgField (fieldName, newType, newLength, newCount)

RERmveField (fieldName)

RENewField (newName, newType, newLength, newCount)

REBegin (fileName)

REUpdate (showProgress, progressProc)

REUpgrade (showProgess, progressProc)



Reorganization:





USSetEOF (usRefNum, logEOF)

USGetEOF (usRefNum) <- theResult

USLockExists (usRefNum, start, count, permission) <- theResult

USLockTest (usRefNum, start, count, permission) <- theResult

USGrab (usRefNum, start, count, permission, wait)

USWrite (usRefNum, count, @buffer)

USRead (usRefNum, count, @buffer)

USGetPosition (usRefNum) <- theResult

USPosition (usRefNum, posMode, position)

USClose (usRefNum)

USOpen (fileName) <- usRefNum



Unstructured File Operations:





SRDeleteView (viewName)

SRCloseView

SRViewNewFile (fName, statusMask)

SRViewNewKey (localName, fileName, keyName)

     fileName, fieldName)

SRViewNewField (localName, fldType, fldCount, fldLength,

SROpenView (viewName)

SRNewView (viewName)



View Maintenance:





SRClear (vwRefNum, @viewBuffer)

SRInitVwBuff (vwRefNum, @viewBuffer)

SRClearCurrent (vwRefNum)

SRCurrentRecord (fName) <- theResult

SRSetRecID (fileName, theRec)

SRGetRecID (fileName) <- theRec

SRRestore (vwRefNum, saveRecHdl)

SRSave (vwRefNum, saveRecHdl)



SRGetPosition (vwRefNum) <- theResult

SRPosition (vwRefNum, thePos, @viewBuffer, permission, wait) <- theResult

SRPositionLast (vwRefNum, @viewBuffer, permission, wait) <- theResult

SRPositionFirst (vwRefNum, @viewBuffer, permission, wait) <- theResult

     wait) <- theResult

SRPrevious (vwRefNum, wrap, exactMatch, lastField, @viewBuffer, permission,

     wait) <- theResult

SRNext (vwRefNum, wrap, exactMatch, lastField, @viewBuffer, permission,

SRGetCount (vwRefNum) <- theResult

     permission, wait) <- theResult

SRFindRange (vwRefNum, @viewBuffer1, @viewBuffer2, lastField, exactMatch,

     wait) <- theResult

SRFindLast (vwRefNum, @viewBuffer, lastField, exactMatch, permission,

     wait) <- theResult

SRFindFirst (vwRefNum, @viewBuffer, lastField, exactMatch, permission,



     permission, wait) <- theResult

SRDeleteWithPrev (vwRefNum, wrap, exactMatch, lastField, @viewBuffer,

     permission, wait) <- theResult

SRDeleteWithNext (vwRefNum, wrap, exactMatch, lastField, @viewBuffer,

SRDelete (vwRefNum)

SRUpdate (vwRefNum, @viewBuffer)

SRRead (vwRefNum, @viewBuffer, permission, wait)

SRLockExists (vwRefNum, permission) <- theResult

SRLockTest (vwRefNum, permission) <- theResult

SRGrab (vwRefNum, permission, wait)

SRInsert (vwRefNum, @viewBuffer)



SRSize (fileName) <- theResult

SRSetBalance (fileName, keyName, balance)

SRGetCurrKey (vwRefNum) <- keyName

SRSelectKey (vwRefNum, keyName)

SRClose (vwRefNum)

SROpen (viewName) <- vwRefNum



Structured Record Operations:





FSetEncryption (fileName, key)

FGetTime (fileName) <- crTime, modTime, reorgTime

FEmpty (fileName)

FDelete (fileName)

FLockExists (fileName, permission) <- theResult

FLockTest (fileName, permission) <- theResult

FGrab (fileName, permission, wait)

FConnect (childFile, parentFile)

FCreate (fileName, fType)



File Operations:





ISOUnloadSeg



ISOFlushIO

ISOHoldIO



ISOGetTime <- crTime, modTime, reorgTime

ISOGetRefNum (fileNum) <- fileRefNum

ISOSetFileSize (fileNum, newBlkCount, maxFileSize)

ISOGetFileSize (fileNum) <- blksUsed, blksAvailable, maxFileSize

ISOSelectFile (fileNum)

ISOCreateExtFile (fileName, vRefNum, startFileSize, maxFileSize)

ISOCountFiles <- theResult



ISOSetExtProc (@makeProc, @findProc)



ISOPopError

ISOPushError (@errProc, @var)

ISOErrText (err) <- theText

ISOError <- theResult



ISORepair (@problemRec, showProgress) <- repaired

ISOCheck (fName, showProgress, fullCheck, @problemRec) <- theResult



ISOIdle

ISOChgPassword (oldPass, newPass)

ISOResetStatus (fileName, vRefNum) <- theResult

ISOClose

ISOGetCurrentDBRefNum (VAR theCurrentDBsRefNum) <- theResult

ISOSetCurrentDB (aDBREfNumber);

     recoverMode, password, forceFind)

ISOOpen (fileName, vRefNum, creator, fileType, extdType, imageFileType, permission,

     recoverMode, password)

ISOCreate (fileName, vRefNum, creator, fileType, extdType, imageFileType, permission,



Database Operations:



     SRSave handles

     Lock list handles

     View buffers

The following can be either an address or a dynamic variable name:

Numbers are assumed to be decimal unless prefixed by $.

Pointer parameters are specified as hex or decimal addresses and are prefixed by @.



    Boolean: t=TRUE; f=FALSE

                 sh=lockShared; ex=lockExclusive

    Permissions: rd=readOnly; sc=lockSecure; up=lockUpdate; dl=lockDelete

Constants: